Restores Poco-side modifications dropped by the upstream sync:

- src/sqlparser_win.h: Windows DLL export macros (SQLParser_API
  driven by Data_API when included from Poco, or SQLParser_EXPORTS
  standalone), _WIN32 strncasecmp/strcasecmp aliases, GCC visibility
  fallback.
- SQLParser_API annotation on every public class/struct/free function
  in src/SQLParser.h, src/SQLParserResult.h, all of src/sql/*.h
  (including new upstream types CsvOptions, ImportExportOptions,
  ReferencesSpecification, ForeignKeyConstraint, ColumnConstraints),
  and src/util/sqlhelper.h.
- sqlparser_win.h includes in SQLParserResult.h, sql/ColumnType.h,
  sql/SQLStatement.h, util/sqlhelper.h.
- SQLParser.h: [[deprecated(Use parse())]] attributes on the legacy
  parseSQLString overloads.
- SQLParserResult.{h,cpp}: pointerize statements_ and parameters_ as
  pointer-to-vector with mutable lazy allocation; reset(bool mv)
  supports move-construct case; setErrorDetails frees previous
  errorMsg_ to plug a leak. Upstream did not touch this file in the
  imported range so the patch applied cleanly.
- src/parser/bison_parser.cpp: MSVC pragma (disable: 4996, 4267)
  around generated code.
- src/parser/flex_lexer.{cpp,h}: MSVC pragma around generated code,
  Windows io.h replacement for unistd.h, __has_include(<stdint.h>)
  guard on flex INT*_MIN/MAX fallbacks.
- src/sql/Expr.cpp: MSVC pragma around strncpy use in substr().
- Makefile: add -I. -Isrc/ to LIB_CFLAGS and TEST_CFLAGS, normalize
  TEST_CFLAGS to -std=c++17.

Verified: standalone make + make test pass (sql_tests success, no
leaks). Poco Data shared library (debug and release) builds and
links cleanly.

…er.h #5370

Restored fork-local removal of #include sql/statements.h from
SQLParser.h. The include was originally pulled in transitively by
SQLParser.h, but it dragged the full per-statement type set into
every translation unit that included SQLParser.h, which created
ambiguity issues elsewhere in the Poco tree. Consumers that need
the concrete statement types include sql/statements.h directly.
SQLParserResult.h still pulls in SQLStatement.h, which is enough
for Poco::Data::Statement which only touches SQLStatement::type().

…5370

Adds a Linux job that builds the vendored sql-parser sources with
its own Makefile and runs the upstream test suite. Closes the
coverage gap where Poco CI compiles SQLParser into libPocoData but
only exercises it indirectly through Poco::Data::Statement smoke
tests in DataTest. The new job actually parses queries-good.sql and
queries-bad.sql, runs valgrind for leaks, and re-runs bison to
check the grammar is conflict-free.

Triggered by the new sqlparser path filter (Data/SQLParser only),
so it does not run on every Data change. bison, flex, and valgrind
are installed via apt; ubuntu-24.04 ships versions well above the
3.0 / 2.6 minimums the Makefile requires.

…5370

Extends the vendored hyrise sql-parser to recognize two placeholder
syntaxes in addition to the existing standard ?:

- $N (postgresql 1-based explicit numbering, e.g. WHERE a = $1)
- :name (sqlite named, e.g. WHERE a = :user)

Implementation:

- New lexer rules for the two patterns, placed before the punctuation
  catch-all. $ was previously unused. : remained a punctuation token
  but had no grammar references, so the longer :identifier match wins
  without conflict.
- New bison tokens DOLLAR_PARAM (carries the int N) and NAMED_PARAM
  (carries the identifier). param_expr now accepts all three forms.
  $0 is rejected via YYERROR at parse time.
- Three ExprType values: kExprParameter for ?, kExprParameterDollar
  for $N (ival = N), kExprParameterNamed for :name (name = identifier).
  This keeps consumer switch statements explicit instead of overloading
  a single enum with discriminator fields.
- Factory functions Expr::makeDollarParameter and Expr::makeNamedParameter.
  isLiteral returns true for all three. The destructor already frees
  name so no further changes are needed.
- The top-level input rule only renumbers ? placeholders sequentially;
  $N keeps its explicit ival, :name keeps its name. addParameter still
  sorts by ival, which now orders $N by explicit position and clusters
  named placeholders.
- sqlhelper print case extended to handle the two new ExprType values.
- sql_asserts.h now pulls sql/statements.h, restoring the include that
  prepare_tests.cpp and friends used to get transitively through
  SQLParser.h before the earlier sync removed it.

Verified: standalone make + make test pass cleanly. All three checks
green (sql tests including three new placeholder cases, valgrind, and
bison grammar conflict). Poco Data lib (debug and release shared)
builds and links cleanly via the poco_env.bash flow.

Imports Poco::Data::Utility from macchina.io:

- Utility::renderValue<T> renders a single C++ value as a SQL literal.
  Handles nullptr, Poco::Nullable, std::optional, bool, integral and
  floating types, Date/Time/DateTime/LocalDateTime, BLOB (X'...' hex),
  CLOB, Poco::Dynamic::Var (recursive), and anything string-view-like
  (single-quoted with internal ' doubled). Unknown types fall back to
  ? so the rendered text stays valid-shaped.

- Utility::boundSQL<...> renders a parameterised SQL template by
  substituting placeholders with stringified bindings. Currently a
  hand-rolled state-machine scanner supporting ? and $N styles with
  literal-awareness. (Switch to parser-backed substitution in a
  follow-up commit.)

- Utility::executeSQL<...> wraps Statement execution, captures stmt,
  bindings, timing, rows-affected/error and reports the outcome via a
  structured ExecResult callback.

- Utility::toJSON serialises an ExecResult as a JSON object with RFC
  8259 string escaping.

Adds 22 UtilityTest cases under Data/SQLite/testsuite covering
renderValue dispatch, boundSQL placeholder handling and arity errors,
executeSQL success/constraint/malformed/null paths, and toJSON
formatting. The testsuite passes against the in-tree hand-rolled
scanner; the follow-up parser refactor must keep it green.

The placeholder param_expr actions now set ival2 to the source column
(0-based) of the placeholder's first character. For ? the column is
yylloc.total_column - 1, for $N total_column - (1 + digits of N), for
:name total_column - 1 - strlen(name).

ival2 was previously written once for ? (yyloc.param_list.size(), which
duplicated the sequential id later stored in ival by the top-level
renumber loop) and never read anywhere in Poco. Repurposing it for the
source column gives all three placeholder kinds a consistent meaning:
ival -> id (sequential for ?, explicit N for $N, 0 for :name);
ival2 -> source column.

This lets consumers walk parameters() sorted by ival2 and substitute
placeholders against the original SQL text without having to re-scan
it themselves.

prepare_tests.cpp gains ival2 assertions on the four placeholder cases
(? / $N in-order / $N out-of-order / :name) validating the computed
column positions match hand-counted offsets.

The top-level input rule's renumber loop is unchanged - it only writes
ival for kExprParameter, leaving ival2 alone.

Verified: standalone make test passes all three checks.

…y::boundSQL #5371

Utility::boundSQL now parses the input SQL with hsql::SQLParser,
walks result.parameters() sorted by Expr::ival2 (source column),
and substitutes by position. Replaces the hand-rolled state-machine
scanner that duplicated lexer responsibilities (literal-awareness,
$N parsing, mixing detection). The parser handles single-quoted
literals natively, so placeholders inside strings are inert.

- ? and $N substitute as before; arity and mixing errors throw
  Poco::InvalidArgumentException with the same call sites/messages.
- :name placeholders are now pass-through (left verbatim in the
  output). The renderer does not bind by name; future Statement-level
  work can complete that.
- Unparseable SQL throws InvalidArgumentException; executeSQL
  catches and falls back to the raw template string, matching the
  pre-existing contract that callbacks always get a populated sql.
- The POCO_DATA_NO_SQL_PARSER build retains the original hand-rolled
  scanner as a fallback so the no-parser CI matrix keeps working.

Also lifts the upstream parser's ban on ? in extended_literal
contexts (INSERT VALUES, EXECUTE args). The rejection at
bison_parser.y:1098 ("Parameter ? is not a valid literal.") was
inconsistent with the newer $N / :name placeholders, which the same
rule accepts. Common INSERT INTO t VALUES(?, ?, ?) patterns now
parse natively. Two queries-bad.sql cases that asserted the
rejection move to queries-good.sql.

UtilityTest SQL strings updated to wrap VALUES(...) fragments inside
INSERT INTO t — the parser-based path validates structure, so bare
VALUES() fragments are no longer accepted (they were a quirk of the
text-only scanner). testExecuteSQLMalformed adjusted to assert the
fall-through behavior (raw sql preserved when boundSQL throws).

Verified: SQLite testsuite 122 tests pass (SQLiteTest 100 +
UtilityTest 22). Standalone SQLParser make test passes all three
checks. flex_lexer.{cpp,h} were regenerated but the byte-identical
output to HEAD means they are not in this commit.

…ndering #5371

DataException carries the raw template SQL (placeholders, no values). When
a Statement throws, operators see "INSERT INTO t VALUES(?, ?, ?)" rather
than the actual bound payload. Adding rendering inside DataException would
change default log shape and silently leak PII into every existing logger.
Instead, expose an opt-in helper callers invoke from a catch block:

  try { stmt.execute(); }
  catch (Poco::Data::DataException& e) {
      log("failed: " + Utility::boundSQL(stmt) + " - " + e.displayText());
  }

The helper walks the Statement's bindings, swaps each one's binder to a
RenderingBinder, drives bind() row by row up to maxRows (default 1), then
restores the original binder. Two reset() calls bracket the bind loop so
the helper works whether the Statement was previously executed or not, and
leaves bindings ready for a subsequent execute() / boundSQL() call.

To make the cascade safe, RenderingBinder::reset() is now a no-op: scalar
Binding<T>::reset() calls pBinder->reset(), which would otherwise wipe
captures from earlier walked bindings. The binder is scoped to one render
call and discarded, so there is nothing to clean up.

recordScalar() now appends to the per-position slot instead of overwriting,
so container bindings driven row-by-row accumulate per-row captures. For
scalar bindings (one bind() per pos) the slot still ends up with exactly
one entry, so the existing boundSQL<Args...> template path is unaffected.

Adds Statement::bindings() public accessors (impl() is protected) and
RenderingBinder::setTotalRows() so the helper can communicate the
binding-derived row count to the suffix logic in boundSQLImpl.

Five new UtilityTest cases cover scalar / vector / bulk / custom
TypeHandler / preserves-execute paths; all 30 cases pass in make,
cmake parser-enabled, and cmake POCO_DATA_NO_SQL_PARSER=ON matrices.

ColumnConstraints owns two heap-allocated members (constraints and
references, the latter containing heap-allocated ReferencesSpecification
pointers). On the happy path those pointers transfer into a
ColumnDefinition which deletes them in its destructor; on parse error
bison reaches the wildcard %destructor that only frees the wrapper,
leaking the inner members.

Add a dedicated %destructor for <column_constraints_t> that releases
the inner state before deleting the wrapper. valgrind on
queries-good.sql + queries-bad.sql now reports 15,209 allocs /
15,209 frees, no leaks.

Also correct a typo in microtest.h (inherited from upstream
hyrise/sql-parser): ASSERT_STRNEQ contained '!= = 0' which would fail
to compile if expanded. No callers use the macro so it was dormant,
but it is still broken on its face; change the condition to '== 0'
(the inverse of ASSERT_STREQ).

Backported to ~/sql-parser fork as fba2a75 / e2f2d23 on the
263-placeholders branch.

…5371

CodeQL's cpp/unused-static-variable and cpp/unused-local-variable rules
flag the parameter pack 'bindings' on Utility::boundSQL and
Utility::executeSQL as unused. The pack IS used via expansion (bindings...
forwarded to boundSQLBulk in one case, into renderings/stmt-binding in
the other), but CodeQL's data-flow doesn't track pack expansion through
call arguments. Annotate the parameter packs with [[maybe_unused]] to
suppress the false positive without changing functional behaviour.

Follow-up to ec57eb4. CodeQL also flags 'bindings' and 'pos' inside
boundSQLBulk: both are used in the fold-expression body
(TypeHandler<Args>::bind(pos, bindings, ...), pos += ...), but
CodeQL's data-flow doesn't trace through pack expansion or fold
expressions. Annotate both with [[maybe_unused]] for consistency with
the other variadic wrappers and to suppress the false positives.

…ence #5373

MemoryDB is an in-memory SQLite database with sharded persistence to disk.
Behaves like a Poco::Data::Session (operator<<, into, use, now); persists
incrementally to a directory of shard files via a background flush timer,
at destruction, and on demand via flush(). Live data stays in RAM in the
active shard; sealed shards stay on disk and are attached read-only on
demand via attachArchived() / historyView().

Features:
- sharded persistence with size and age seal triggers
- retention policies: Options::retentionMaxAge and retentionMaxBytes
- always-on SQLITE_LIMIT_ATTACHED backstop on total shard count (oldest
  sealed shards auto-dropped at flush time when the cap would be exceeded;
  a warning is logged via the Poco.Data.SQLite.MemoryDB logger)
- history queries spanning the active shard plus sealed shards on disk,
  via attachArchived/detachArchived or full / time-range historyView()
- WITHOUT ROWID tables rejected up front (sharding partitions by rowid)
- thread-safe: attach/detach/historyView serialize internally via
  sqlite3_db_mutex so user statements on the shared Session never see a
  half-attached connection; attach bookkeeping is reference-counted so
  concurrent attachers of the same shard pair correctly
- crash-safe: shard files written via temp + atomic rename, manifest
  commits in a single transaction; worst-case loss bounded by the
  idle/max-flush window

Includes:
- Data/SQLite/{include,src}/MemoryDB.{h,cpp}
- Data/SQLite/testsuite/src/MemoryDBTest.{h,cpp}: ~30 tests covering
  persistence, retention, history views, deleteShard semantics, the
  always-on shard-ceiling auto-drop, and a 5-second concurrent stress
  test (1 writer + N readers/historians/admin) that completes clean
  under release and ThreadSanitizer
- Data/samples/MemoryDB: usage sample
- Wiring: SQLiteTestSuite registers MemoryDBTest (and the previously
  landed SQLiteThreadSafetyTest); testsuite Makefile/CMakeLists pull in
  MemoryDBTest under the same SQL parser guard as MemoryDB itself

Supporting Data layer changes folded in (originally #5371):
- Utility::executeSQL takes std::string context instead of
  std::unique_ptr<std::string>; empty string means none. Removes one heap
  allocation per call and reads better at call sites.
- Utility::boundSQL(stmt) wraps the per-binding binder swap in a RAII
  guard so an exception in a user TypeHandler<T>::bind cannot leave a
  binding pointing at a destroyed RenderingBinder.
- Utility.h doc updates: explicit not-thread-safe-with-respect-to-the-
  Statement contract on boundSQL(stmt) / boundSQLBulk(stmt); dialect
  caveat on the formatBLOB X'AABB' hex literal form (SQLite/MySQL/
  standard-SQL, not portable to PostgreSQL bytea or MS SQL 0xAABB).

…5370

Two leaks in SQLParser::tokenize():

1. SQL_NAMED_PARAM (added in #263) strdup()s the parameter name into
   yylval.sval at flex_lexer.l:247, but the cleanup branch only checked
   SQL_IDENTIFIER and SQL_STRING -- every :name placeholder leaked.

2. The loop lexed a token, pushed it, lexed the next, then checked the
   next token's type and freed yylval.sval. Because the second lex
   overwrote yylval, the first sval-bearing token's pointer was lost.
   What got freed was always the next token's sval -- correct in steady
   state but a guaranteed leak on the first sval-bearing token of every
   tokenize() call.

Restructure: lex once per iteration, free immediately if the token type
allocates an sval, push, loop. The token set mirrors bison's own
 at bison_parser.y:194, so the
direct-lex (tokenize) path and the parse path now clean up the same set.

…5371

Utility::renderValue<T> falls through to the
std::is_convertible_v<const T&, std::string_view> branch for T = const char*
or char*, then calls std::string_view(v). When v is null this hits the
string_view(const char*) constructor's contract violation (traits::length
on nullptr is UB). The nullptr-literal branch at the top of renderValue
only matches T = std::nullptr_t and so doesn't catch a pointer variable
that happens to be null.

Fold an is_pointer_v compile-time guard into the string_view branch so
character-pointer types null-check at runtime and return NULL, matching
what the bind layer would emit for a null pointer. std::string,
std::string_view, and other non-pointer types implicitly convertible to
string_view stay on the existing fast path (no runtime branch added).

Test: const char* and char* null variants assert NULL in
UtilityTest::testRenderValue, alongside the existing nullptr-literal case.

… dir #5373

Follow-up to b0efe72. That commit added /Data/SQLite/src/
(gnu-make) and /Data/SQLite/src/ (cmake) to the
testrunner include path so MemoryDBTest.cpp's #include <sqlite3.h>
would resolve. The Linux gnu-make build worked because Data/SQLite's
own Makefile runs an  prebuild that drops a sqlite3.h symlink there. The Windows cmake
build doesn't run that prebuild - sqlite3.h was never present at that
path, and ninja failed with:

    fatal error C1083: Cannot open include file: 'sqlite3.h':
    No such file or directory

Point at the canonical bundled SQLite header location instead:

  cmake:    PRIVATE $<TARGET_PROPERTY:SQLite::SQLite3,
                                       INTERFACE_INCLUDE_DIRECTORIES>
            (resolves to dependencies/sqlite3/src for bundled, or the
            find_package(SQLite3) result for POCO_SQLITE_UNBUNDLED;
            takes only the include dirs from the SQLite::SQLite3
            target, no link, so PocoDataSQLite's already-linked SQLite
            object library isn't pulled in a second time)

  gnu-make: /dependencies/sqlite3/src
            (always present in the source checkout; the system header
            on the default include path takes over for unbundled)

Both work on Linux and Windows, bundled or unbundled, regardless of
whether Data/SQLite's prebuild has ever run.

…tatic #5373

Follow-up to the previous testsuite include-path fix. MemoryDBTest's
testShardCeilingAutoDrop and testHistoryViewTimeRangeOverflow call
sqlite3_limit() directly to constrain the runtime SQLITE_LIMIT_ATTACHED
cap. The include resolution worked once we routed the test's <sqlite3.h>
through dependencies/sqlite3/src, but Windows clang-cmake then failed
at link:

    lld-link: error: undefined symbol: sqlite3_limit
    >>> referenced by ... MemoryDBTest.cpp.obj

The bundled SQLite is compiled into PocoDataSQLite.lib via an OBJECT
library (BUILD_LOCAL_INTERFACE PRIVATE). On Linux .so the symbols are
exported by default; on Windows static (.lib with POCO_STATIC) nothing
without __declspec(dllexport) is visible to downstream linkers, and
SQLITE_API doesn't emit one. Linking SQLite::SQLite3 directly into the
testrunner would re-pull the OBJECT library's .o files and clash with
PocoDataSQLite's already-linked copies.

Wrap it in POCO: Utility::setAttachedLimit(Session&, int newVal). The
wrapper carries the SQLite_API export through PocoDataSQLite's normal
public surface, so the testrunner (and any external caller) gets a
portable way to set SQLite's per-connection attached-DB cap without
needing the raw handle, <sqlite3.h>, or a direct link against the
bundled SQLite object library.

Tests now call Utility::setAttachedLimit instead of sqlite3_limit.
MemoryDBTest.cpp drops its #include <sqlite3.h>, and the include-path
fixes from the previous commit (testsuite CMakeLists pointing at
SQLite::SQLite3's INTERFACE_INCLUDE_DIRECTORIES, testsuite Makefile
pointing at dependencies/sqlite3/src) are reverted - no longer needed.

Audit-driven fixes to MemoryDB:

- _columnCopyCache populate-after-DDL race: a writer racing onDDL could
  reinstall the pre-DDL ColumnCopy and silently drop newly-added columns
  on the next flush. Snapshot _schemaVersion before releasing the lock
  and only install if unchanged.
- doFlush could miss a CREATE TABLE that landed in the sample-to-lock
  window: the new table was absent from the slice plan, its row stayed
  in main but never reached disk, and _dirty got cleared. Re-sample
  userTables after the IO loop and set _dirty if any appeared. The dtor
  now unconditionally flushes with allowSeal=false to catch this case
  without producing a fresh shard on shutdown.
- onDDL incremented _schemaVersion before _schemaLog.push_back; bad_alloc
  on vector growth desynchronized the two and the next catalog write
  committed version N+1 with N log entries. Swap the order so the only
  throwing op runs first.
- _sealRequested arriving after maybeSeal but before the post-IO _dirty
  recompute would be lost until the next user write. Fold it into the
  recompute.
- traceCallback rejected only on sql[0]==-; this matched the SQLite
  trigger-subprogram marker but also any user statement starting with a
  -- comment, letting a WITHOUT ROWID CREATE through via the session()
  bypass. Skip -- and slash-star comment prefixes before classification.
- WITHOUT ROWID rejection could be lost if the _rejected string
  assignment threw bad_alloc. Set a noexcept atomic _poisoned first;
  throwIfRejected uses an atomic fast path and a static fallback reason.
- detachArchived held _attachMutex across its 1ms retry sleep, blocking
  deleteShard (which holds _flushMutex) and transitively stalling flush.
  Release and re-acquire each iteration; the refcount is re-checked so
  concurrent attaches stay correct.
- deleteShard is now idempotent on a vanished id (returns silently
  instead of throwing) so retention loops over a stale shards() snapshot
  stay correct under concurrency.

Header docs updated to capture the three-mutex layering rationale and
the new contracts. Redundant inner _stateMutex acquisitions on _attached
removed since _attachMutex now solely covers it. New lastFlushTime()
accessor for time-bounded durability waits. testDeleteNonexistentShardRefused
updated for the new no-throw contract.

Adds tests that lock down the parser-layer behaviour POCO's production
code relies on, plus reproductions of recent fix motivations so any
upstream sql-parser sync that regresses them fails loudly in the test
layer rather than silently in MemoryDB / Utility.

Data/testsuite/src/SQLParserTest:
- testResetClearsParameters: reparse loop with reset() between
  iterations - the lifecycle the upstream sval-leak fix hardened.
- testNamedParameter: :name placeholders parse to kExprParameterNamed
  with names {user, age}.
- testAlterDropColumnIfExists: down-casts to AlterStatement +
  DropColumnAction and asserts columnName, ifExists, table name.
- testDropDiscrimination: DROP TABLE vs DROP INDEX dispatch.
- testDeleteShape: DeleteStatement::expr nullptr distinguishes truncate
  from filtered delete - what MemoryDB branches on for the truncate
  optimization.
- testComments: -- line comments survive parsing across statements.
- testTokenize: backstops the SQLParser::tokenize loop the upstream
  sval-leak fix rewrote.
- Inline fix to the pre-existing testSQLParser failure formatter: L13
  was rendering with no separator between line and column; replaced
  with L<line>:C<col> and switched bare fail() to failmsg() so the
  formatted message actually surfaces on the CppUnit report.

Data/SQLite/testsuite/src/UtilityTest:
- testBoundSQLNamed: pins the current pass-through behaviour of :name
  placeholders in Utility::boundSQL (Utility.cpp kExprParameterNamed
  branch sets paramIndex=npos so the span is copied verbatim and the
  supplied args are silently ignored). If this branch is ever taught
  to substitute values, the test must be rewritten.

Data/SQLite/testsuite/src/MemoryDBTest:
- testCommentPrefixedWithoutRowidRejected: covers both operator<< and
  session() bypass paths with a leading -- comment. Pins the motivation
  for the leading-comment-skip rewrite in onStatement; the previous
  single-char trigger-marker check let -- prefixed CREATE bypass the
  trace-hook backstop.
- testDropTableClassified: DROP TABLE survives close-reopen via the
  schema log, proving the kStmtDrop + kDropTable dispatch.
- testAlterTableClassified: ALTER TABLE ADD COLUMN survives close-
  reopen. ADD COLUMN is not modelled as an AlterAction by hsql so this
  exercises the first-keyword DDL fallback in onStatement.

The bison/flex regen in 01f7ec2 overwrote a POCO-local hand-patch
in the generated flex_lexer.h that wrapped the unistd.h include in a
Windows guard. MSVC has no unistd.h, so clang-cl Windows builds
fail with:

  flex_lexer.h(470): fatal error: 'unistd.h' file not found

Re-apply the same conditional, with a POCO-LOCAL comment so the next
person who regens the lexer knows it has to be re-applied. flex's
%option set in flex_lexer.l has no equivalent for this - nounistd
would drop the include on every platform but flex's emitted runtime
calls (read/write/close/isatty) need either unistd.h or io.h, so the
conditional has to live in the generated header.

#5377

e23f9a1 patched the same guard in flex_lexer.h but missed the
matching include in flex_lexer.cpp:3184, which also fails to compile
on clang-cl Windows. Apply the identical conditional in the .cpp.
Same caveat as before: lives in the generated file, must be
re-applied after every flex regen.